/**
 * 分析数据流集成测试
 * 
 * 本文件用于测试完整的分析数据流程：
 * 1. 模拟脑波数据生成
 * 2. 数据发送到分析服务端
 * 3. 轮询获取分析结果
 * 4. UI数据更新
 * 
 * 使用方法：
 * - 确保分析服务端运行在 http://192.168.2.12:8000
 * - 运行测试验证数据流的完整性
 * 
 * 原理：
 * - 使用 AnalysisDataManager 管理数据流
 * - 模拟真实的用户操作场景
 * - 验证各个状态转换的正确性
 */

package com.example.brain_wave.integration

import com.example.brain_wave.data.AnalysisDataManager
import com.example.brain_wave.data.AnalysisDataManagerState
import com.example.brain_wave.api.AnalysisResponse
import com.example.brain_wave.model.BrainWaveDataPoint
import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.delay
import org.junit.Test
import org.junit.Assert.*
import java.util.concurrent.CountDownLatch
import java.util.concurrent.TimeUnit

class AnalysisIntegrationTest {
    
    private val analysisServerUrl = "http://192.168.2.12:8000"
    private val testRoomId = "test_room_001"
    private val testUserId = "test_user_001"
    
    @Test
    fun testCompleteAnalysisDataFlow() = runTest {
        // 创建分析数据管理器
        val analysisDataManager = AnalysisDataManager()
        
        // 状态跟踪
        var currentState = AnalysisDataManagerState.IDLE
        var receivedResults: List<AnalysisResponse> = emptyList()
        var receivedDataPoints: List<BrainWaveDataPoint> = emptyList()
        var errorMessage: String? = null
        
        // 设置回调
        analysisDataManager.setOnStateChangeCallback { state ->
            currentState = state
            println("状态变更: $state")
        }
        
        analysisDataManager.setOnAnalysisResultCallback { results ->
            receivedResults = results
            println("收到分析结果: ${results.size} 条")
        }
        
        analysisDataManager.setOnDataPointGeneratedCallback { dataPoint ->
            receivedDataPoints = receivedDataPoints + dataPoint
            println("生成数据点: ${dataPoint.timestamp}")
        }
        
        analysisDataManager.setOnErrorCallback { error ->
            errorMessage = error
            println("错误: $error")
        }
        
        // 初始化管理器
        analysisDataManager.initialize(
            baseUrl = analysisServerUrl,
            roomId = testRoomId,
            userId = testUserId
        )
        
        // 验证初始状态
        assertEquals(AnalysisDataManagerState.IDLE, currentState)
        
        // 开始数据流
        analysisDataManager.startDataFlow()
        
        // 等待状态变化和数据生成
        delay(5000) // 等待5秒让数据流运行
        
        // 验证状态转换
        assertTrue("应该不再是IDLE状态", currentState != AnalysisDataManagerState.IDLE)
        
        // 验证数据点生成
        assertTrue("应该生成了数据点", receivedDataPoints.isNotEmpty())
        println("生成的数据点数量: ${receivedDataPoints.size}")
        
        // 验证数据点的有效性
        receivedDataPoints.forEach { dataPoint ->
            assertTrue("Alpha值应该在合理范围内", dataPoint.alpha in 0.0..100.0)
            assertTrue("Beta值应该在合理范围内", dataPoint.beta in 0.0..100.0)
            assertTrue("Theta值应该在合理范围内", dataPoint.theta in 0.0..100.0)
            assertTrue("Delta值应该在合理范围内", dataPoint.delta in 0.0..100.0)
            assertTrue("时间戳应该大于0", dataPoint.timestamp > 0)
        }
        
        // 等待更长时间以获取分析结果
        delay(10000) // 再等待10秒
        
        // 验证是否收到分析结果（如果服务端正常运行）
        if (errorMessage == null) {
            println("分析结果数量: ${receivedResults.size}")
            
            // 如果收到结果，验证结果的有效性
            receivedResults.forEach { result ->
                assertNotNull("会话ID不应为空", result.sessionId)
                assertNotNull("频率带数据不应为空", result.frequencyBands)
                assertTrue("时间戳应该大于0", result.timestamp > 0)
            }
        } else {
            println("测试期间发生错误: $errorMessage")
            // 如果是网络错误，这是可以接受的（服务端可能未运行）
            assertTrue("错误应该是网络相关的", 
                errorMessage!!.contains("Connection") || 
                errorMessage!!.contains("timeout") ||
                errorMessage!!.contains("refused"))
        }
        
        // 停止数据流
        analysisDataManager.stopDataFlow()
        
        // 等待停止完成
        delay(1000)
        
        // 验证最终状态
        assertEquals("停止后应该回到IDLE状态", AnalysisDataManagerState.IDLE, currentState)
        
        // 清理资源
        analysisDataManager.cleanup()
        
        println("集成测试完成")
    }
    
    @Test
    fun testAnalysisDataManagerStateTransitions() = runTest {
        val analysisDataManager = AnalysisDataManager()
        val stateHistory = mutableListOf<AnalysisDataManagerState>()
        
        // 记录状态变化
        analysisDataManager.setOnStateChangeCallback { state ->
            stateHistory.add(state)
        }
        
        // 初始化
        analysisDataManager.initialize(
            baseUrl = analysisServerUrl,
            roomId = testRoomId,
            userId = testUserId
        )
        
        // 开始数据流
        analysisDataManager.startDataFlow()
        
        // 等待状态变化
        delay(3000)
        
        // 停止数据流
        analysisDataManager.stopDataFlow()
        
        // 等待停止完成
        delay(1000)
        
        // 验证状态转换序列
        assertTrue("应该有状态变化", stateHistory.isNotEmpty())
        assertEquals("初始状态应该是IDLE", AnalysisDataManagerState.IDLE, stateHistory.first())
        
        // 验证包含预期的状态
        val expectedStates = setOf(
            AnalysisDataManagerState.IDLE,
            AnalysisDataManagerState.GENERATING,
            AnalysisDataManagerState.SENDING
        )
        
        val actualStates = stateHistory.toSet()
        assertTrue("应该包含基本状态", actualStates.intersect(expectedStates).isNotEmpty())
        
        // 清理
        analysisDataManager.cleanup()
        
        println("状态转换测试完成，状态历史: $stateHistory")
    }
    
    @Test
    fun testErrorHandling() = runTest {
        val analysisDataManager = AnalysisDataManager()
        var errorReceived = false
        var errorMessage: String? = null
        
        // 设置错误回调
        analysisDataManager.setOnErrorCallback { error ->
            errorReceived = true
            errorMessage = error
        }
        
        // 使用无效的服务端URL
        analysisDataManager.initialize(
            baseUrl = "http://invalid-server:9999",
            roomId = testRoomId,
            userId = testUserId
        )
        
        // 开始数据流
        analysisDataManager.startDataFlow()
        
        // 等待错误发生
        delay(5000)
        
        // 验证错误处理
        assertTrue("应该收到错误", errorReceived)
        assertNotNull("错误消息不应为空", errorMessage)
        
        // 停止并清理
        analysisDataManager.stopDataFlow()
        analysisDataManager.cleanup()
        
        println("错误处理测试完成，错误消息: $errorMessage")
    }
}